/**
 * 手动读写文件：
 * fs.open(), fs.read(), fs.write(), fs.close();
 *  读一点写一点，也就是流的方式
 *  i/o 读写的参照物 内存
 *  要将一个文件内容读取到内存，其实是做了写的操作
 *  要将内存的东西写入到一个文件中，其实是做了读的操作
 */

const fs = require('fs');
const path = require('path');

const buffer = Buffer.alloc(3);
const buffer2 = Buffer.from('海涛');
// 修饰符：r是读，w是写，a是追加
/* fs.open('./xx.js', 'r', (err, fd) => {
  // fd（file discriptor）：是一个递增数字，文件操作符
  console.log('fd', fd);
  fs.read(fd, buffer, 0, 3, 0, (err, bytesRead) => {
    console.log('bytesRead', bytesRead);
    fs.close(fd, () => {
      console.log('读取完毕');
    })
  })
}) */

// 写入
// 0o66：写入权限，文件操作是有权限的，777是最大的权限，r(读)：4，w(写)：2，x(执行)：1
// 0o66是八进制，可读可写
/* fs.open('./xx.js', 'w', 0o66, (err, fd) => {
  fs.write(fd, buffer2, 0, 3, 0, (err, writen) => {
    console.log(writen);
  })
}) */

// 封装一个拷贝函数，先读再写
/**
 * 
 * @param {*} source 源文件地址
 * @param {*} target 目标地址
 * @param {*} cb     回调函数
 */
function copy(source, target, cb) {

  const LENGTH = 3;
  const buffer = Buffer.alloc(LENGTH);
  let read_position = 0;
  let write_position = 0;

  fs.open(source, 'w', (err, wFd) => {

    fs.open(target, 'r', (err, rFd) => {
      // 异步迭代用函数
      function next() {
        fs.read(rFd, buffer, 0, LENGTH, read_position, function (err, bytesRead) {

          if (err) return cb(err);
          if (bytesRead) {
            fs.write(wFd, buffer, 0, bytesRead, write_position, function (err, written) {
              read_position += bytesRead;
              write_position += bytesRead;
              next();
            })
          } else {
            fs.close(rFd, () => {})
            fs.close(wFd, () => {})
            cb();
          }
        })
      }
      next();

    })

  })
}
copy('./4.fs.js', './xx.js', function () {
  console.log('success');
});